home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / termCapture.c < prev    next >
C/C++ Source or Header  |  1995-09-26  |  10KB  |  532 lines
  1. /*
  2. **    termCapture.c
  3. **
  4. **    File and printer capture support routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. STATIC VOID __regargs
  13. CaptureCallback1(register APTR Buffer,register LONG Size)
  14. {
  15.     AddLine(Buffer,Size);
  16.  
  17.     CaptureToFile(Buffer,Size);
  18.     CaptureToFile("\n",1);
  19. }
  20.  
  21. STATIC VOID __regargs
  22. CaptureCallback3(register APTR Buffer,register LONG Size)
  23. {
  24.     AddLine(Buffer,Size);
  25.  
  26.     CaptureToFile(Buffer,Size);
  27.     CaptureToFile("\n",1);
  28.  
  29.     CaptureToPrinter(Buffer,Size);
  30.     CaptureToPrinter("\n",1);
  31. }
  32.  
  33. STATIC VOID __regargs
  34. CaptureCallback4(register APTR Buffer,register LONG Size)
  35. {
  36.     CaptureToFile(Buffer,Size);
  37.     CaptureToFile("\n",1);
  38. }
  39.  
  40. STATIC VOID __regargs
  41. CaptureCallback5(register APTR Buffer,register LONG Size)
  42. {
  43.     CaptureToFile(Buffer,Size);
  44.     CaptureToFile("\n",1);
  45.  
  46.     CaptureToPrinter(Buffer,Size);
  47.     CaptureToPrinter("\n",1);
  48. }
  49.  
  50. STATIC VOID __regargs
  51. CaptureCallback6(register APTR Buffer,register LONG Size)
  52. {
  53.     CaptureToPrinter(Buffer,Size);
  54.     CaptureToPrinter("\n",1);
  55. }
  56.  
  57. STATIC VOID __regargs
  58. CaptureCallback7(register APTR Buffer,register LONG Size)
  59. {
  60.     AddLine(Buffer,Size);
  61.  
  62.     CaptureToPrinter(Buffer,Size);
  63.     CaptureToPrinter("\n",1);
  64. }
  65.  
  66. VOID __regargs
  67. CaptureFilteredTo_Buffer(register APTR Buffer,register LONG Size)
  68. {
  69.     CaptureParser(Buffer,Size,AddLine);
  70. }
  71.  
  72. VOID __regargs
  73. CaptureFilteredTo_Buffer_File(register APTR Buffer,register LONG Size)
  74. {
  75.     CaptureParser(Buffer,Size,CaptureCallback1);
  76. }
  77.  
  78. VOID __regargs
  79. CaptureFilteredTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
  80. {
  81.     CaptureParser(Buffer,Size,CaptureCallback3);
  82. }
  83.  
  84. VOID __regargs
  85. CaptureFilteredTo_File(register APTR Buffer,register LONG Size)
  86. {
  87.     CaptureParser(Buffer,Size,CaptureCallback4);
  88. }
  89.  
  90. VOID __regargs
  91. CaptureFilteredTo_File_Printer(register APTR Buffer,register LONG Size)
  92. {
  93.     CaptureParser(Buffer,Size,CaptureCallback5);
  94. }
  95.  
  96. VOID __regargs
  97. CaptureFilteredTo_Printer(register APTR Buffer,register LONG Size)
  98. {
  99.     CaptureParser(Buffer,Size,CaptureCallback6);
  100. }
  101.  
  102. VOID __regargs
  103. CaptureFilteredTo_Buffer_Printer(register APTR Buffer,register LONG Size)
  104. {
  105.     CaptureParser(Buffer,Size,CaptureCallback7);
  106. }
  107.  
  108. VOID __regargs
  109. CaptureRawTo_Buffer(register APTR Buffer,register LONG Size)
  110. {
  111.     CaptureParser(Buffer,Size,AddLine);
  112. }
  113.  
  114. VOID __regargs
  115. CaptureRawTo_Buffer_File(register APTR Buffer,register LONG Size)
  116. {
  117.     CaptureParser(Buffer,Size,AddLine);
  118.  
  119.     CaptureToFile(Buffer,Size);
  120. }
  121.  
  122. VOID __regargs
  123. CaptureRawTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
  124. {
  125.     CaptureParser(Buffer,Size,AddLine);
  126.  
  127.     CaptureToFile(Buffer,Size);
  128.     CaptureToPrinter(Buffer,Size);
  129. }
  130.  
  131. VOID __regargs
  132. CaptureRawTo_Buffer_Printer(register APTR Buffer,register LONG Size)
  133. {
  134.     CaptureParser(Buffer,Size,AddLine);
  135.  
  136.     CaptureToPrinter(Buffer,Size);
  137. }
  138.  
  139. VOID __regargs
  140. CaptureRawTo_File(register APTR Buffer,register LONG Size)
  141. {
  142.     CaptureToFile(Buffer,Size);
  143. }
  144.  
  145. VOID __regargs
  146. CaptureRawTo_File_Printer(register APTR Buffer,register LONG Size)
  147. {
  148.     CaptureToFile(Buffer,Size);
  149.     CaptureToPrinter(Buffer,Size);
  150. }
  151.  
  152. VOID __regargs
  153. CaptureRawTo_Printer(register APTR Buffer,register LONG Size)
  154. {
  155.     CaptureToPrinter(Buffer,Size);
  156. }
  157.  
  158.     /* ClosePrinterCapture(BYTE Force):
  159.      *
  160.      *    Closes printer capture file.
  161.      */
  162.  
  163. VOID __regargs
  164. ClosePrinterCapture(BYTE Force)
  165. {
  166.     if(PrinterCapture)
  167.     {
  168.         if(ControllerActive && StandardPrinterCapture && !Force)
  169.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_ENDING_TXT));
  170.  
  171.         if(Force)
  172.         {
  173.             Close(PrinterCapture);
  174.  
  175.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  176.  
  177.             PrinterCapture = NULL;
  178.  
  179.             ConOutputUpdate();
  180.  
  181.             StandardPrinterCapture = FALSE;
  182.         }
  183.     }
  184.  
  185.     ControllerActive = FALSE;
  186.  
  187.     ConOutputUpdate();
  188. }
  189.  
  190.     /* OpenPrinterCapture(BYTE Controller):
  191.      *
  192.      *    Opens printer capture file.
  193.      */
  194.  
  195. BYTE __regargs
  196. OpenPrinterCapture(BYTE Controller)
  197. {
  198.     if(PrinterCapture)
  199.     {
  200.         if(Controller && !ControllerActive)
  201.         {
  202.             ControllerActive = TRUE;
  203.  
  204.             ConOutputUpdate();
  205.  
  206.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  207.         }
  208.  
  209.         return(TRUE);
  210.     }
  211.     else
  212.     {
  213.         if(PrinterCapture = Open("PRT:",MODE_NEWFILE))
  214.             CheckItem(MEN_CAPTURE_TO_PRINTER,TRUE);
  215.         else
  216.         {
  217.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  218.  
  219.             BlockWindows();
  220.  
  221.             MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_ERROR_OPENING_PRINTER_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),"PRT:");
  222.  
  223.             ReleaseWindows();
  224.         }
  225.  
  226.         if(Controller)
  227.         {
  228.             ControllerActive    = TRUE;
  229.             StandardPrinterCapture    = FALSE;
  230.         }
  231.         else
  232.         {
  233.             StandardPrinterCapture = FALSE;
  234.  
  235.             if(ControllerActive)
  236.                 FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_USER_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  237.         }
  238.  
  239.         ConOutputUpdate();
  240.  
  241.         if(PrinterCapture)
  242.             return(TRUE);
  243.         else
  244.             return(FALSE);
  245.     }
  246. }
  247.  
  248.     /* CloseFileCapture():
  249.      *
  250.      *    Close the capture file.
  251.      */
  252.  
  253. VOID
  254. CloseFileCapture()
  255. {
  256.     if(FileCapture)
  257.     {
  258.         BufferClose(FileCapture);
  259.  
  260.         FileCapture = NULL;
  261.  
  262.         if(!GetFileSize(CaptureName))
  263.             DeleteFile(CaptureName);
  264.         else
  265.         {
  266.             AddProtection(CaptureName,FIBF_EXECUTE);
  267.  
  268.             if(Config -> MiscConfig -> CreateIcons)
  269.                 AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  270.         }
  271.     }
  272.  
  273.     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  274.     CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);
  275.  
  276.     RawCapture = FALSE;
  277.  
  278.     ConOutputUpdate();
  279. }
  280.  
  281.     /* OpenFileCapture():
  282.      *
  283.      *    Open a capture file.
  284.      */
  285.  
  286. BYTE __regargs
  287. OpenFileCapture(BOOL Raw)
  288. {
  289.     struct FileRequester    *FileRequest;
  290.     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  291.                 *DummyChar;
  292.     BYTE             Aborted = FALSE;
  293.  
  294.     CloseFileCapture();
  295.  
  296.     BlockWindows();
  297.  
  298.     if(!CaptureName[0])
  299.     {
  300.         strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);
  301.  
  302.         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
  303.             CaptureName[0] = 0;
  304.     }
  305.  
  306.     strcpy(DummyBuffer,CaptureName);
  307.  
  308.     DummyChar = PathPart(DummyBuffer);
  309.  
  310.     *DummyChar = 0;
  311.  
  312.     if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
  313.     {
  314.         if(GetFileSize(DummyBuffer))
  315.         {
  316.             switch(MyEasyRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  317.             {
  318.                 case 1:
  319.  
  320.                     FileCapture = BufferOpen(DummyBuffer,"w");
  321.                     break;
  322.  
  323.                 case 2:
  324.  
  325.                     FileCapture = BufferOpen(DummyBuffer,"a");
  326.                     break;
  327.  
  328.                 case 0:
  329.  
  330.                     FileCapture = NULL;
  331.  
  332.                     Aborted = TRUE;
  333.  
  334.                     break;
  335.             }
  336.         }
  337.         else
  338.             FileCapture = BufferOpen(DummyBuffer,"w");
  339.  
  340.         if(!Aborted)
  341.         {
  342.             if(!FileCapture)
  343.                 ShowError(Window,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  344.             else
  345.                 strcpy(CaptureName,DummyBuffer);
  346.         }
  347.  
  348.         FreeAslRequest(FileRequest);
  349.     }
  350.  
  351.     if(Raw)
  352.     {
  353.         if(FileCapture)
  354.             CheckItem(MEN_CAPTURE_TO_RAW_FILE,TRUE);
  355.         else
  356.             CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);
  357.  
  358.         RawCapture = TRUE;
  359.     }
  360.     else
  361.     {
  362.         if(FileCapture)
  363.             CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  364.         else
  365.             CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  366.  
  367.         RawCapture = FALSE;
  368.     }
  369.  
  370.     ConOutputUpdate();
  371.  
  372.     ReleaseWindows();
  373.  
  374.     if(FileCapture)
  375.         return(TRUE);
  376.     else
  377.         return(FALSE);
  378. }
  379.  
  380.     /* CaptureToFile(APTR Buffer,LONG Size):
  381.      *
  382.      *    Send data to the capture file.
  383.      */
  384.  
  385. VOID __regargs
  386. CaptureToFile(APTR Buffer,LONG Size)
  387. {
  388.     if(Size)
  389.     {
  390.         if(BufferWrite(FileCapture,Buffer,Size) != Size)
  391.         {
  392.             BlockWindows();
  393.  
  394.                 /* We had an error writing to the file. */
  395.  
  396.             switch(MyEasyRequest(NULL,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_CAPTURE_FILE_TXT),LocaleString(MSG_CONSOLE_IGNORE_DISCARD_CLOSE_TXT),CaptureName))
  397.             {
  398.                 case 1:
  399.  
  400.                     BufferClose(FileCapture);
  401.  
  402.                     DeleteFile(CaptureName);
  403.  
  404.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  405.  
  406.                     FileCapture = NULL;
  407.  
  408.                     ConOutputUpdate();
  409.  
  410.                     break;
  411.  
  412.                 case 2:
  413.  
  414.                     BufferClose(FileCapture);
  415.  
  416.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  417.  
  418.                     FileCapture = NULL;
  419.  
  420.                     if(!GetFileSize(CaptureName))
  421.                         DeleteFile(CaptureName);
  422.                     else
  423.                     {
  424.                         AddProtection(CaptureName,FIBF_EXECUTE);
  425.  
  426.                         if(Config -> MiscConfig -> CreateIcons)
  427.                             AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  428.                     }
  429.  
  430.                     ConOutputUpdate();
  431.  
  432.                     break;
  433.             }
  434.  
  435.             ReleaseWindows();
  436.         }
  437.     }
  438. }
  439.  
  440.     /* CaptureToPrinter(APTR Buffer,LONG Size):
  441.      *
  442.      *    Send capture data to the printer, convert the
  443.      *    characters as necessary to avoid shocking the
  444.      *    printer.
  445.      */
  446.  
  447. VOID __regargs
  448. CaptureToPrinter(APTR Buffer,LONG Size)
  449. {
  450.     if(!Config -> CaptureConfig -> ConvertChars && Config -> TerminalConfig -> FontMode != FONT_STANDARD)
  451.     {
  452.         UBYTE     LocalBuffer[BUFFER_LINE_MAX];
  453.  
  454.         UBYTE    *Src = Buffer,
  455.             *Dst,
  456.              c;
  457.  
  458.         ULONG     Count;
  459.  
  460.         while(Size > 0)
  461.         {
  462.             Count = MIN(Size,BUFFER_LINE_MAX);
  463.  
  464.             Size -= Count;
  465.  
  466.             Dst = LocalBuffer;
  467.  
  468.             do
  469.             {
  470.                 if(c = ISOConversion[*Src++])
  471.                     *Dst++ = c;
  472.                 else
  473.                     *Dst++ = ' ';
  474.             }
  475.             while(--Count > 0);
  476.  
  477.             Count = (ULONG)Dst - (ULONG)&LocalBuffer[0];
  478.  
  479.             while(Count > 0 && LocalBuffer[Count - 1] == ' ')
  480.                 Count--;
  481.  
  482.             if(Count > 0)
  483.             {
  484.                 if(FWrite(PrinterCapture,LocalBuffer,Count,1) != 1)
  485.                 {
  486.                     BlockWindows();
  487.  
  488.                     if(!MyEasyRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  489.                     {
  490.                         Close(PrinterCapture);
  491.  
  492.                         CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  493.  
  494.                         PrinterCapture = NULL;
  495.  
  496.                         ConOutputUpdate();
  497.  
  498.                         Size = 0;
  499.                     }
  500.  
  501.                     ReleaseWindows();
  502.                 }
  503.             }
  504.         }
  505.     }
  506.     else
  507.     {
  508.         if(Size > 0)
  509.         {
  510.                 /* Send the buffer to the printer. */
  511.  
  512.             if(FWrite(PrinterCapture,Buffer,Size,1) != 1)
  513.             {
  514.                 BlockWindows();
  515.  
  516.                 if(!MyEasyRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  517.                 {
  518.                     Close(PrinterCapture);
  519.  
  520.                     CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  521.  
  522.                     PrinterCapture = NULL;
  523.  
  524.                     ConOutputUpdate();
  525.                 }
  526.  
  527.                 ReleaseWindows();
  528.             }
  529.         }
  530.     }
  531. }
  532.